package cn.lcsjsxy.yxc.io;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * 一、
 * 1.按操作数据单位不同分为：字节流（8 bit），字符流（16 bit）
 * 2.按数据流的流向不同分为：输入流，输出流
 * 3.按流的角色的不同分为：节点流，处理流
 * <p>
 * 二、流的体系结构
 * 抽象基类    字节流         字符流
 * 输入流     InputStream   Reader
 * 输出流     OutputSteam   Writer
 * （1）Java的IO流涉及40多个子类，实际上非常规则，都是从如下4个抽象基类派生的
 * （2）由这四个类派生出来的子类名称都是以其父类名作为子类名后缀
 * <p>
 * 节点流（或文件流）                                   缓冲流（处理流的一种）
 * FileInputStream （read（byte[] buffer））          BufferedInputStream
 * FileOutputSteam  (write(byte[] buffer,0,len))    BufferedOutputStream
 * FileReader       (read(char[] cbuf)/readLine())  BufferedReader
 * FileWriter       (write(char[] cbuf,0,len))      BufferedWriter
 */
public class FileReaderWriterTest {
//
//    public static void main(String[] args) {
//        File file=new File("hello.txt");  //相较于当前工程
//        System.out.println(file.getAbsolutePath());
//    }

    /*
     * 将java下的hello.txt文件读入程序中，并输出到控制台
     *
     * 说明点：
     * 1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
     * 2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
     * 3.读入的文件一定要存在，否则就会报FileNotFoundException
     * */
    @Test
    public void testFileReader() {
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操做的文件
            File file = new File("hello.txt");  //相较于当前Module
            System.out.println("文件是否存在：" + file.exists());

            //2.提供具体的流
            fr = new FileReader(file);

            //3.数据的读入
            //read():返回读入的一个字符，如果达到文件末尾，返回-1
            //方式一：
//        int data = fr.read();
//        while (data!=-1){
//            System.out.print((char) data);
//            data=fr.read();
//        }

            //方式二：语法上针对于方式一的修改
            int data;
            while ((data = fr.read()) != -1) {
                System.out.println((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4.流的关闭操做
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //对read（）操作升级：使用read的重载方法
    @Test
    public void testFileReader1() {
        FileReader fr = null;

        try {
            //1.File类的实例化
            File file = new File("hello.txt");
            System.out.println(file.exists());

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            //方式一：
            char[] chars = new char[20];
            int len;

//            len = fr.read(chars);
//            System.out.println(len);  11
//            len = fr.read(chars);
//            System.out.println(len);  -1

            while ((len = fr.read(chars)) != -1) {

                for (int i = 0; i < len; i++) {
                    System.out.print(chars[i]);
                }

                System.out.println();

                //方式二：
                String str = new String(chars, 0, len);
                System.out.print(str);
            }

        } catch (
                Exception e) {
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            try {
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /*
     * 从内存中写出数据到硬盘的文件里
     *
     * 说明：
     * 1.输出操做，对应的File可以不存在的。并不会报异常
     * 2.
     *       》File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
     *       》File对应的硬盘中的文件如果存在：
     *                           当流使用的构造器是：FileWriter(fileName,false) / FileWriter(file):对原有文件的覆盖
     *                           当流使用的构造器是：FileWriter(fileName,false):不会对原有文件覆盖，而是追加新内容
     * */
    @Test
    public void FileWriterTest() {
        FileWriter fw = null;

        try {
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file, false);  //FileWriter(fileName,append)  append: true 在原有文件上追加内容   false 覆盖原文件内容

            //3.写出的操做
            fw.write("郝雨晴");
            fw.write("\n杨效晨");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //4.资源的关闭
                if (fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //读写合并操做
    @Test
    public void ReaderAndWriterTest() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //创建File
            File file1 = new File("hello.txt");
            File file2 = new File("hello1.txt");

            //提供reader和writer
            fr = new FileReader(file1);
            fw = new FileWriter(file2, true);
            int read, len;
            char[] love = new char[50];

            //输入和写出
            while ((len = fr.read(love)) != -1) {
                for (int i = 0; i < len; i++) {
                    System.out.print(love[i]);
                }
                String str = new String(love, 0, len);
                fw.write("\n" + str);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //关闭
            try {
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testFileReaderFileWriter() {
        FileReader fReader = null;
        FileWriter fWriter = null;

        try {
            //1.创建File对象
            File file = new File("hello1.txt");
            File copyFile = new File("copyHello1.txt");

            //2.提供输入流和输出流
            fReader = new FileReader(file);
            fWriter = new FileWriter(copyFile, false);

            //3.读写操做
            int len;
            char[] chars = new char[5];
//            if ((len=fReader.read(chars))!=-1){
//                String str=new String(chars,0,len);
//                fWriter.write(str);
//            }

            while ((len = fReader.read(chars)) != -1) {
                fWriter.write(chars, 0, len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //4.关闭流
            try {
                if (fReader != null) {
                    fReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if (fWriter != null) {
                    fWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void pictureTest() {
        FileReader fReader = null;
        FileWriter fWriter = null;

        try {
            //1.创建File对象
            File file = new File("老马啊啊啊.jpg");
            File copyFile = new File("老马啊啊啊1.jpg");

            //2.提供输入流和输出流
            fReader = new FileReader(file);
            fWriter = new FileWriter(copyFile, false);

            //3.读写操做
            int len;
            char[] chars = new char[5];
//            if ((len=fReader.read(chars))!=-1){
//                String str=new String(chars,0,len);
//                fWriter.write(str);
//            }

            while ((len = fReader.read(chars)) != -1) {
                fWriter.write(chars, 0, len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //4.关闭流
            try {
                if (fReader != null) {
                    fReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if (fWriter != null) {
                    fWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

